diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 86c89fe..86e7b75 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -158,6 +158,7 @@
 <ul>
 	<li>Removed an extraneous call to loading models (#3286).</li>
 	<li>Removed extraneous load of $CFG in _display_cache() of the Output class (#3285)</li>
+	<li>Fixed a bug (#3330) in the FTP class where a comparison wasn't getting made.</li>
 	<li>Fixed a bug (#3310) with sanitization of globals in the Input class that could unset CI's global variables.</li>
 	<li>Fixed a bug (#1890) in csv_from_result() where content that included the delimiter would break the file.</li>
 	<li>Fixed a bug (#3156) in Text Helper highlight_code() causing PHP tags to be handled incorrectly.</li>
@@ -200,7 +201,7 @@
     <li>Fixed an example of <kbd>accept_charset()</kbd> in the <a href="./libraries/user_agent.html">User Agent Library</a>.</li>
     <li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor.</li>
     <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid).</li>
-    <li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login).</li>
+    <li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login), and FTP Class (ftp_unable_to_remame).</li>
     <li>Added a stripslashes()  into the Upload Library.</li>
     <li>Fixed assorted user guide typos.</li>
 </ul>
